{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# 配列\n",
    "\n",
    "* Arrayクラスのインスタンス\n",
    "    * 配列リテラル\n",
    "        * 要素を角カッコで囲み、要素の間をカンマで区切ることで生成する\n",
    "    * Arrayクラスのインスタンスを生成することで配列を作成可能\n",
    "    * 初期値は第二引数やブロックで指定\n",
    "    * 第二引数で指定したオブジェクトは同一オブジェクト\n",
    "    * 破壊的メソッドで変更するとすべての配列の値が変更されることになる\n",
    "    * ブロックで初期化することですべての配列の値が変更されることを防ぐことができる"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "配列リテラル : 要素を角カッコで囲み、要素の間をカンマで区切ることで生成する\n",
      "[10, true, \"foo\", :bar]\n",
      "10\n",
      "\n",
      "初期値は第二引数やブロックで指定\n",
      "[nil, nil, nil]\n",
      "3\n",
      "[\"foo\", \"foo\", \"foo\"]\n",
      "[\"bar\", \"bar\", \"bar\"]\n",
      "[\"hoge\", \"hoge\", \"hoge\"]\n",
      "[0, 1, 2]\n",
      "[1, 2, 3]\n",
      "[3, 4, 5]\n",
      "\n",
      "第二引数で指定したオブジェクトは同一オブジェクト\n",
      "[\"fuga\", \"fuga\", \"fuga\"]\n",
      "70145222431020\n",
      "70145222431020\n",
      "70145222431020\n",
      "\n",
      "破壊的メソッドで変更するとすべての配列の値が変更されることになる\n",
      "[\"haga\", \"haga\", \"haga\"]\n",
      "[\"zzz\", \"zzz\", \"zzz\"]\n",
      "\n",
      "ブロックで初期化することですべての配列の値が変更されることを防ぐことができる\n",
      "[\"xxx\", \"xxx\", \"xxx\"]\n",
      "70145222332900\n",
      "70145222332880\n",
      "70145222332860\n",
      "[\"yyy\", \"xxx\", \"xxx\"]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"yyy\", \"xxx\", \"xxx\"]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puts \"配列リテラル : 要素を角カッコで囲み、要素の間をカンマで区切ることで生成する\"\n",
    "p a = [10, true, \"foo\", :bar]   #=> [10, true, \"foo\", :bar]\n",
    "p a[0]                          #=> 10\n",
    "puts\n",
    "\n",
    "puts \"初期値は第二引数やブロックで指定\"\n",
    "p v1 = Array.new(3)               #=> [nil, nil, nil]\n",
    "p v1.length                       #=> 3\n",
    "p v2 = Array.new(3,\"foo\")         #=> [\"foo\", \"foo\", \"foo\"]\n",
    "p v3 = Array.new(3){\"bar\"}        #=> [\"bar\", \"bar\", \"bar\"]\n",
    "p Array.new(3){|v| v = \"hoge\"}    #=> [\"hoge\", \"hoge\", \"hoge\"]\n",
    "p Array.new(3){|v| v}             #=> [0, 1, 2]\n",
    "p Array.new(3){|v| v + 1}         #=> [1, 2, 3]\n",
    "p Array.new(3){|v| v + 3}         #=> [3, 4, 5]\n",
    "puts\n",
    "\n",
    "puts \"第二引数で指定したオブジェクトは同一オブジェクト\"\n",
    "p v4 = Array.new(3,\"fuga\")        #=> [\"fuga\", \"fuga\", \"fuga\"]\n",
    "p v4[0].object_id                 #=> (69924207752260など)\n",
    "p v4[1].object_id                 #=> (69924207752260など上と同じ)\n",
    "p v4[2].object_id                 #=> (69924207752260など上と同じ)\n",
    "puts\n",
    "\n",
    "puts \"破壊的メソッドで変更するとすべての配列の値が変更されることになる\"\n",
    "p v5 = Array.new(3,\"haga\")        #=> [\"haga\", \"haga\", \"haga\"]\n",
    "v5[0].replace(\"zzz\")\n",
    "p v5                              #=> [\"zzz\", \"zzz\", \"zzz\"]\n",
    "puts\n",
    "\n",
    "puts \"ブロックで初期化することですべての配列の値が変更されることを防ぐことができる\"\n",
    "p v6 = Array.new(3){\"xxx\"}          #=> [\"xxx\", \"xxx\", \"xxx\"]\n",
    "p v6[0].object_id                 #=> (70099484225320など)\n",
    "p v6[1].object_id                 #=> (70099484225300など上と異なる)\n",
    "p v6[2].object_id                 #=> (70099484225280など上と異なる)\n",
    "v6[0].replace(\"yyy\")\n",
    "p v6                                #=> [\"yyy\", \"xxx\", \"xxx\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, nil, 1]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [\"a\",\"b\",\"c\"]\n",
    "c = a.dup\n",
    "a[4] = 1\n",
    "puts a\n",
    "puts c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "* 二次元配列\n",
    "* パーセント記法による配列の生成\n",
    "    * %Wでダブルクオート、%wでシングルクオート区切りの配列\n",
    "    * 素間は空白区切り\n",
    "* サイズを超えた要素への代入\n",
    "    * 配列のサイズは要素の代入によって動的に変わる\n",
    "    * 上限を超えた場合はnilを返す\n",
    "* 添え字演算子\n",
    "    * 配列の要素への参照や代入\n",
    "        * 構文ではなくArrayクラスのメソッドとして実装されている\n",
    "        * 参照\n",
    "            * []メソッド\n",
    "        * 代入\n",
    "            * []=メソッド\n",
    "    * 添え字として負の整数や複数の整数を指定できる\n",
    "    * <font color=\"Red\">要素を指定して代入</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "二次元配列\n",
      "[[1, 2], [\"a\", \"b\"]]\n",
      "[1, 2]\n",
      "2\n",
      "\n",
      "パーセント記法による配列の生成\n",
      "[\"abc\", \"def\", \"foo\"]\n",
      "[\"ghi\", \"jkl\", \"\\#{bar}\"]\n",
      "\"abc&def&foo\"\n",
      "\n",
      "サイズを超えた要素への代入\n",
      "[\"hoge\"]\n",
      "[\"hoge\", nil, nil, \"fuga\"]\n",
      "nil\n",
      "\n",
      "添え字演算子\n",
      "[\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
      "\"a\"\n",
      "\"e\"\n",
      "\"d\"\n",
      "\"b\"\n",
      "nil\n",
      "[\"c\", \"d\", \"e\"]\n",
      "[\"d\", \"e\"]\n",
      "\n",
      "要素を指定して代入\n",
      "[\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
      "[\"a\", \"f\", \"d\", \"e\"]\n",
      "[\"a\", \"g\", \"h\", \"e\"]\n",
      "\n",
      "多重代入と可変長引数\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "4\n",
      "5\n",
      "6\n",
      "1\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puts \"二次元配列\"\n",
    "p b = [[1,2],[\"a\",\"b\"]]         #=> [[1, 2], [\"a\", \"b\"]]\n",
    "p b[0]                          #=> [1,2]\n",
    "p b[0][1]                       #=> 2\n",
    "puts\n",
    "\n",
    "puts \"パーセント記法による配列の生成\"\n",
    "foo=\"foo\"\n",
    "bar=\"bar\"\n",
    "p %W(abc def #{foo})              #=> [\"abc\", \"def\", \"foo\"]\n",
    "p %w(ghi jkl #{bar})              #=> [\"ghi\", \"jkl\", \"\\#{bar}\"]\n",
    "p %W(abc def #{foo}).join(\"&\")    #=> \"abc&def&foo\"\n",
    "puts\n",
    "\n",
    "puts \"サイズを超えた要素への代入\"\n",
    "p v1 = [\"hoge\"]                  #=> [\"hoge\"]\n",
    "v1[3] = \"fuga\"\n",
    "p v1                             #=> [\"hoge\", nil, nil, \"fuga\"]\n",
    "p v1[9]                          #=> nil\n",
    "puts\n",
    "\n",
    "puts \"添え字演算子\"\n",
    "p v1 = [\"a\",\"b\",\"c\",\"d\",\"e\"]      #=> [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
    "p v1[0]                           #=> \"a\"   ### 先頭の要素\n",
    "p v1[-1]                          #=> \"e\"   ### 末尾の要素\n",
    "p v1[4-1]                         #=> \"d\"   ### 4-1 = 3  先頭を0番目として3の要素\n",
    "p v1[-4]                          #=> \"b\"   ### 末尾を1番目として4番目の要素\n",
    "p v1[-9]                          #=> nil   ### 上限を超えたらnil\n",
    "p v1[2,3]                         #=> [\"c\", \"d\", \"e\"]  ### 先頭を0番目としてインデックス2(2番目の要素)からそれ自身を含めて後ろ3つの要素を表示\n",
    "p v1[3,2]                         #=> [\"d\", \"e\"]  ### 先頭を0番目としてインデックス3(3番目の要素)からそれ自身を含めて後ろ2つの要素を表示\n",
    "puts\n",
    "\n",
    "puts \"要素を指定して代入\"\n",
    "p v2 = [\"a\",\"b\",\"c\",\"d\",\"e\"]      #=> [\"a\", \"b\", \"c\", \"d\", \"e\"] ### 先頭を0番目の要素として1,2番目の要素b,cが操作対象\n",
    "v2[1,2] = \"f\"                     ### インデックス1を含めて2要素分を1要素として\"f\"を代入。\n",
    "p v2                              #=> [\"a\", \"f\", \"d\", \"e\"]  ### 1,2番目の要素だったb,cが1つの要素fになった\n",
    "v2[1,2] = [\"g\",\"h\"]               ### インデックス1を含めて1要素目にg,2要素目にhを代入。\n",
    "p v2                              #=> [\"a\", \"g\", \"h\", \"e\"]  ### 1,2番目の要素f,dにg,hが代入されて置き換わった\n",
    "puts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"1\", \"2\", \"3\"]\n",
      "[\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
      "[\"a\", \"f\", \"d\", \"e\"]\n",
      "[\"a\", \"f\", \"d\", \"e\"]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"a\", \"f\", \"d\", \"e\"]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puts %W(1 2 3)\n",
    "\n",
    "p v2 = [\"a\",\"b\",\"c\",\"d\",\"e\"] \n",
    "v3 = v2\n",
    "v2[1,2] = \"f\" \n",
    "p v2\n",
    "p v3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "多重代入と可変長引数\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "右辺の数が少ない場合はnilが入る\n",
      "10\n",
      "20\n",
      "nil\n",
      "\n",
      "メソッドの返り値で代入\n",
      "4\n",
      "5\n",
      "6\n",
      "\n",
      "配列で代入\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "カッコを付けて代入\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "[1, 2]\n",
      "3\n",
      "nil\n",
      "\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puts \"多重代入と可変長引数\"\n",
    "a, b, c = 1, 2, 3\n",
    "p a\n",
    "p b\n",
    "p c\n",
    "puts\n",
    "\n",
    "puts \"右辺の数が少ない場合はnilが入る\"\n",
    "a, b, x = 10, 20\n",
    "p a\n",
    "p b\n",
    "p x\n",
    "puts\n",
    "\n",
    "def foo2\n",
    "  return 4, 5, 6\n",
    "end\n",
    "\n",
    "puts \"メソッドの返り値で代入\"\n",
    "d, e, f = foo2\n",
    "p d\n",
    "p e\n",
    "p f\n",
    "puts \n",
    "\n",
    "puts \"配列で代入\"\n",
    "a, b, c = [1, 2, 3]\n",
    "p a\n",
    "p b\n",
    "p c\n",
    "puts \n",
    "\n",
    "puts \"カッコを付けて代入\"\n",
    "(a, b), c = [1, 2], 3\n",
    "p a\n",
    "p b\n",
    "p c\n",
    "puts \n",
    "\n",
    "a, b, c = [1, 2], 3\n",
    "p a\n",
    "p b\n",
    "p c\n",
    "puts \n",
    "\n",
    "\n",
    "p a = 1, 2, 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# 可変長引数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "可変長引数\n",
      "1\n",
      "[2, 3]\n",
      "\n",
      "メソッドの中\n",
      "[2, 3]\n",
      "\n",
      "可変長引数を他のメソッドに渡す\n",
      "d = [3, 4]\n"
     ]
    }
   ],
   "source": [
    "puts \"可変長引数\"\n",
    "a, *b = 1, 2, 3\n",
    "puts a\n",
    "puts b\n",
    "puts\n",
    "\n",
    "puts \"メソッドの中\"\n",
    "def foo c, *d\n",
    "  puts d\n",
    "end\n",
    "foo(1, 2, 3)\n",
    "puts\n",
    "\n",
    "puts \"可変長引数を他のメソッドに渡す\"\n",
    "def foo1 a, *b\n",
    "  foo2(*b)\n",
    "end\n",
    "\n",
    "def foo2 c, *d\n",
    "   puts \"d = #{d}\"\n",
    "end\n",
    "\n",
    "foo1(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "func1\n",
      "1\n",
      "[2, 3, 4, 5]\n",
      "func2\n",
      "[2, 3, 4, 5]\n",
      "func3\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "\n",
      "func2\n",
      "[1, 2, 3, 4, 5]\n",
      "\n",
      "func3\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def func1(a, *b)\n",
    "  puts \"func1\"\n",
    "  puts a\n",
    "  puts b\n",
    "  func2(*b)\n",
    "  func3(*b)\n",
    "end\n",
    "\n",
    "def func2(*x)\n",
    "  puts \"func2\"\n",
    "  puts x\n",
    "end\n",
    "def func3(*y)\n",
    "  puts \"func3\"\n",
    "  puts *y\n",
    "end\n",
    "\n",
    "func1(1,2,3,4,5)\n",
    "puts\n",
    "func2(1,2,3,4,5)\n",
    "puts\n",
    "func3(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# 配列の演算\n",
    "\n",
    "* &\n",
    "    * 集合の積演算で、両方に含まれる要素からなる配列を返す        \n",
    "* |\n",
    "    * 集合の和演算で、どちらかに含まれる要素からなる配列を返す\n",
    "* +\n",
    "    * 要素をつなげた配列を返す\n",
    "* -\n",
    "    * 右のオペランドで指定された要素が全て取り除かれた配列を返す\n",
    "* `*`\n",
    "    * 右のオペランドが数値の場合、その数だけ連結した配列を返す\n",
    "    * 右のオペランドが文字列の場合、その文字を区切りとして要素を連結した文字列を返す\n",
    "        * joinメソッドと同じ\n",
    "    \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [1, 1, 2, 3, 0]\n",
      "b = [6, 2, 2, 0, 3, 4, 5]\n",
      "\n",
      "a & b\n",
      "[2, 3, 0]\n",
      "\n",
      "b & a\n",
      "[2, 0, 3]\n",
      "\n",
      "a | b\n",
      "[1, 2, 3, 0, 6, 4, 5]\n",
      "\n",
      "b | a\n",
      "[6, 2, 0, 3, 4, 5, 1]\n",
      "\n",
      "a + b\n",
      "[1, 1, 2, 3, 0, 6, 2, 2, 0, 3, 4, 5]\n",
      "\n",
      "a - b\n",
      "[1, 1]\n",
      "\n",
      "b - a\n",
      "[6, 4, 5]\n",
      "\n",
      "a * 3\n",
      "[1, 1, 2, 3, 0, 1, 1, 2, 3, 0, 1, 1, 2, 3, 0]\n",
      "\n",
      "a * \"/\"\n",
      "1/1/2/3/0\n",
      "\n",
      "a.join(\"-\")\n",
      "1-1-2-3-0\n",
      "1hoge1hoge2hoge3hoge0\n",
      "1, 2, 3, 4, 5, 6, 7, 8\n"
     ]
    }
   ],
   "source": [
    "a = [1, 1, 2, 3, 0]\n",
    "b = [6, 2, 2, 0, 3, 4, 5]\n",
    "\n",
    "puts \"a = #{a}\"\n",
    "puts \"b = #{b}\"\n",
    "puts\n",
    "puts \"a & b\"\n",
    "puts a & b\n",
    "puts\n",
    "puts \"b & a\"\n",
    "puts b & a\n",
    "puts\n",
    "puts \"a | b\"\n",
    "puts a | b\n",
    "puts\n",
    "puts \"b | a\"\n",
    "puts b | a\n",
    "puts\n",
    "puts \"a + b\"\n",
    "puts a + b\n",
    "puts\n",
    "puts \"a - b\"\n",
    "puts a - b\n",
    "puts\n",
    "puts \"b - a\"\n",
    "puts b - a\n",
    "puts\n",
    "puts \"a * 3\"\n",
    "puts a * 3\n",
    "puts\n",
    "puts 'a * \"/\"'\n",
    "puts a * \"/\"\n",
    "puts\n",
    "puts 'a.join(\"-\")'\n",
    "puts a.join(\"-\")\n",
    "puts a * \"hoge\"\n",
    "arr = [1, 2, 3, [4, 5], [6, [7, 8]]]\n",
    "puts arr.join(\", \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# for式\n",
    "\n",
    "* 指定された式の範囲を繰り返し実行する\n",
    "    * 「do」は省略できる\n",
    "* 識別子を複数指定できる\n",
    "* スコープ\n",
    "    * スコープが作成されない\n",
    "        * for文の外でも変数は参照できる\n",
    "    * 「each」はスコープを作成する"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [1, 2, 3]\n",
      "\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "識別子を複数指定\n",
      "j = 1, k= 2\n",
      "j = 3, k= 4\n",
      "\n",
      "for式はスコープが作成されない\n",
      "1\n",
      "2\n",
      "3\n",
      "3\n",
      "\n",
      "eachはスコープが作成される\n",
      "1\n",
      "2\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "puts \"a = #{a}\"\n",
    "puts\n",
    "\n",
    "for i in a do\n",
    "  puts i\n",
    "end\n",
    "puts\n",
    "\n",
    "puts \"識別子を複数指定\"\n",
    "for j,k in [[1,2], [3,4]] do\n",
    "  puts \"j = #{j}, k= #{k}\"\n",
    "end\n",
    "puts\n",
    "\n",
    "puts \"for式はスコープが作成されない\"\n",
    "i = 1\n",
    "for i in a do\n",
    "  puts i\n",
    "end\n",
    "puts i\n",
    "puts\n",
    "\n",
    "puts \"eachはスコープが作成される\"\n",
    "k = 1\n",
    "[1,2,3].each do |k|\n",
    "  puts k\n",
    "end\n",
    "puts k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [1, 2, 3]\n",
      "\n",
      "eachは配列の要素数だけブロックを繰り返し実行する。戻り値はレシーバ(a)自身\n",
      "2\n",
      "4\n",
      "6\n",
      "[1, 2, 3]\n",
      "\n",
      "mapは要素の数だけ繰り返しブロックを実行する。ブロックの戻り値を集めて返す\n",
      "[2, 4, 6]\n",
      "\n",
      "ブロックの中でputsで出力すると戻り値無し(nil)\n",
      "2\n",
      "4\n",
      "6\n",
      "[nil, nil, nil]\n"
     ]
    }
   ],
   "source": [
    "### mapとeachの違い\n",
    "a = [1,2,3]\n",
    "puts \"a = #{a}\"\n",
    "puts\n",
    "\n",
    "puts \"eachは配列の要素数だけブロックを繰り返し実行する。戻り値はレシーバ(a)自身\"\n",
    "b = a.each{|a| puts a * 2}\n",
    "puts b\n",
    "puts \n",
    "\n",
    "puts \"mapは要素の数だけ繰り返しブロックを実行する。ブロックの戻り値を集めて返す\"\n",
    "c = a.map{|a| a * 2}\n",
    "puts c\n",
    "puts\n",
    "\n",
    "puts \"ブロックの中でputsで出力すると戻り値無し(nil)\"\n",
    "d = a.map{|a| puts a * 2}\n",
    "puts d"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.3.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.3.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
